#include <iostream>
#include <string>
#include "tlistaporo.h"
#include "tporo.h"
#include "tvectorporo.h"
#include "tpilaporo.h"


using namespace std;


TListaNodo::TListaNodo ()
{
   anterior=NULL;
   siguiente=NULL;
}
TListaNodo::TListaNodo (TListaNodo & nodo)
{
   this->e=nodo.e;
   this->anterior=nodo.anterior;
   this->siguiente=nodo.siguiente;

}
TListaNodo::~TListaNodo ()
{
   anterior=NULL;
   siguiente=NULL;
}
TListaNodo& TListaNodo::operator=(const TListaNodo & nodo)
{
   if(this!=&nodo)
   {
      this->~TListaNodo();
      this->e=nodo.e;
      this->anterior=nodo.anterior;
      this->siguiente=nodo.siguiente;

   }
   return *this;
}





TListaPosicion::TListaPosicion()
{
   pos=new TListaNodo();
}

TListaPosicion::TListaPosicion(TListaPosicion & listaPos)
{
   pos=new TListaNodo(*listaPos.pos);
}

TListaPosicion::~TListaPosicion()
{
   if(pos)delete pos;
   pos=NULL;
}

TListaPosicion& TListaPosicion::operator=(TListaPosicion &listaPos)
{
   if(this!=&listaPos)
   {
      this->pos=listaPos.pos;
   }
   return *this;
}

bool TListaPosicion::operator==(TListaPosicion & x)
{
   return (pos==x.pos);
}

TListaPosicion TListaPosicion::Anterior()
{
   TListaPosicion a;
   a.pos=pos->anterior;
   return a;
}

TListaPosicion TListaPosicion::Siguiente()
{
   TListaPosicion a;
   a.pos=pos->siguiente;
   return a;
}

bool TListaPosicion::EsVacia()
{
   if(pos!=NULL)
   {
      return true;
   }
   else
   {
      return false;
   }
}




ostream & operator<<(ostream & os, TListaPoro &p)
{
;
}

TListaPoro::TListaPoro()
{
   primero=NULL;
   ultimo=NULL;
}

TListaPoro::TListaPoro (TListaPoro & x)
{
   primero=x.primero;
   ultimo=x.ultimo;
}

TListaPoro::~TListaPoro ()
{
   primero=NULL;
   ultimo=NULL;
}

TListaPoro & TListaPoro::operator=( TListaPoro & x)
{
   if(this != & x)
   {
      this->~TListaPoro();
      primero=NULL;
      ultimo=NULL;
   }
   return *this;
}

bool TListaPoro::operator==(TListaPoro &x)
{
   return(primero==x.primero && ultimo==x.ultimo);
}

TListaPoro TListaPoro::operator+(TListaPoro & x)
{
;
}

TListaPoro TListaPoro::operator-(TListaPoro &)
{
;
}

bool TListaPoro::EsVacia()
{
   return (!primero && !ultimo);
}

bool TListaPoro::Insertar(TPoro &p)
{
   if(!primero || !ultimo)
   {
      primero=ultimo=new TListaNodo();
      primero->e=p;
      primero->anterior=NULL;
      primero->siguiente=NULL;
      return true;
   }
   else
   {
      TListaNodo* PP=primero;
     // TListaNodo* PF=ultimo;
      TPoro* delante=&primero->e;
     // TPoro* detras=&ultimo->e;
      bool encontradoP=false;
     // bool encontradoF=false;
      bool repetido=false;
      while(PP!=NULL && !repetido)
      {
         cout << p << endl;
         //if(*delante==p)repetido=true;

         if(delante->PosicionX()<p.PosicionX())
         {
            delante=&PP->siguiente->e;
            PP=PP->siguiente;
         }
         else if(delante->PosicionY()<p.PosicionY())
         {
            delante=&PP->siguiente->e;
            PP=PP->siguiente;
         }
         else if(delante->Volumen()<p.Volumen())
         {
            delante=&PP->siguiente->e;
            PP=PP->siguiente;
         }
         else encontradoP=true;

         /*
         if(detras->PosicionX()>p.PosicionX())
         {
            detras=&PF->anterior->e;
            PF=PF->anterior;
         }
         else if(detras->PosicionY()>p.PosicionY())
         {
            detras=&PF->anterior->e;
            PF=PF->anterior;
         }
         else if(detras->Volumen()>p.Volumen())
         {
            detras=&PF->anterior->e;
            PF=PF->anterior;
         }
         else encontradoF=true;*/
      }
      if(!repetido && encontradoP)
      {
         TListaNodo* anterior=PP;
         TListaNodo* siguiente=PP->siguiente;
         TListaNodo* actual=new TListaNodo();
         actual->e=p;
         actual->siguiente=anterior->siguiente;
         anterior->siguiente=actual;
         actual->anterior=anterior;
         siguiente->anterior=actual;
      }/*
      if(!repetido && encontradoF)
      {
         TListaNodo* siguiente=PF;
         TListaNodo* anterior=PP->anterior;
         TListaNodo* actual=new TListaNodo();
         actual->siguiente=anterior->siguiente;
         anterior->siguiente=actual;
         actual->anterior=anterior;
         siguiente->anterior=actual;
      }*/
      return !repetido;
   }
}

bool TListaPoro::Borrar(TPoro &)
{
;
}

bool TListaPoro::Borrar(TListaPosicion &)
{
;
}

TPoro TListaPoro::Obtener(TListaPosicion &TLP)
{
   return TLP.pos->e;
}

bool TListaPoro::Buscar(TPoro &p)
{
   TListaNodo* PP=primero;
   TListaNodo* PF=ultimo;
   TPoro* delante=&primero->e;
   TPoro* detras=&ultimo->e;
   bool repetido=false;
   while(PP!=PF || PP->anterior!=PF || !repetido)
   {
      if(*delante==p || *detras==p)repetido=true;
      delante=&PP->siguiente->e;
      PP=PP->siguiente;
      detras=&PF->anterior->e;
      PF=PF->anterior;
   }
   return repetido;
}

int TListaPoro::Longitud()
{
   TListaNodo* PP=primero;
   int i=0;
   for(i=0; PP!=NULL; i++)
   {
      PP=PP->siguiente;
   }
   return i;
}

TListaPosicion TListaPoro::Primera()
{
   TListaPosicion a;
   a.pos=primero;
   return a;
}

TListaPosicion TListaPoro::Ultima()
{
   TListaPosicion a;
   a.pos=ultimo;
   return a;
}

